HAL DMA2D control functions

HAL DMA2D layer configuration

HAL1

HAL2 

HAL_DMA2D_ConfigLayer(DMA2D_HandleTypeDef *hdma2d, uint32_t LayerIdx)

In HAL2, the DMA2D layer configuration is performed using one of the following six mode-specific configuration functions depending on the required mode instead:

  • HAL_DMA2D_SetConfigMemCopy() to configure a transfer for memory-to-memory without Pixel Format Conversion.

  • HAL_DMA2D_SetConfigMemCopyPFC() to configure a transfer for memory-to-memory with Pixel Format Conversion.

  • HAL_DMA2D_SetConfigMemFill() to configure a transfer for memory fill with a fixed color.

  • HAL_DMA2D_SetConfigBlending() to configure a transfer with blending of the two input (foreground and background).

  • HAL_DMA2D_SetConfigBlendingWithFGColor() to configure a transfer for blending an image from the background input with a fixed color on the foreground input.

  • HAL_DMA2D_SetConfigBlendingWithBGColor() to configure a transfer for blending an image from the foreground input with a fixed color on the background input.

HAL1

HAL2

DMA2D memory-to-memory transfer 

DMA2D_HandleTypeDef hdma2d;




/* DMA2D init configuration */
hdma2d.Instance = DMA2D;
hdma2d.Init.Mode = DMA2D_M2M;

hdma2d.Init.ColorMode    = DMA2D_OUTPUT_ARGB8888;
hdma2d.Init.OutputOffset = 0x0;
hdma2d.Init.RedBlueSwap  = DMA2D_RB_REGULAR;
hdma2d.Init.AlphaInverted = DMA2D_REGULAR_ALPHA;

/* DMA2D layer configuration */

hdma2d.LayerCfg[1].AlphaMode = DMA2D_NO_MODIF_ALPHA;
hdma2d.LayerCfg[1].InputAlpha = 0xFF;
hdma2d.LayerCfg[1].InputColorMode = DMA2D_INPUT_ARGB8888;
hdma2d.LayerCfg[1].InputOffset = 0x0;
hdma2d.LayerCfg[1].AlphaInverted = DMA2D_REGULAR_ALPHA;
hdma2d.LayerCfg[1].RedBlueSwap   = DMA2D_RB_REGULAR;


HAL_DMA2D_Init(&hdma2d);
HAL_DMA2D_ConfigLayer(&hdma2d, 1);

hal_dma2d_handle_t hdma2d;
hal_dma2d_mem_copy_config_t p_conf;
/* DMA2D initialization */
HAL_DMA2D_Init(&hdma2d, HAL_DMA2D);

/* DMA2D output configuration */


p_conf.output.p_dest  = (void const*) (uint32_t)&ARGB8888_result;
p_conf.output.color_mode = HAL_DMA2D_OUTPUT_COLOR_ARGB8888;
p_conf.output.offset = 0;



/* DMA2D input configuration */
p_conf.input.p_src = (void const*) (uint32_t)&ARGB8888_Tab;
p_conf.input.alpha_mode = HAL_DMA2D_INPUT_ALPHA_NO_MODIF;
p_conf.input.alpha_value  = 0xFF;
p_conf.input.color_mode   = HAL_DMA2D_INPUT_COLOR_ARGB8888;
p_conf.input.offset   = 0;


p_conf.width = 16;
p_conf.height = 16;

HAL_DMA2D_SetConfigMemCopy(&hdma2d, &p_conf);

DMA2D memory-to-memory transfer with pixel format conversion 

DMA2D_HandleTypeDef hdma2d;




/* DMA2D init configuration */
hdma2d.Instance = DMA2D;
hdma2d.Init.Mode = DMA2D_M2M_PFC;

hdma2d.Init.ColorMode    = DMA2D_OUTPUT_ARGB8888;
hdma2d.Init.OutputOffset = 0x0;
hdma2d.Init.RedBlueSwap  = DMA2D_RB_REGULAR;
hdma2d.Init.AlphaInverted = DMA2D_REGULAR_ALPHA;

/* DMA2D layer configuration */

hdma2d.LayerCfg[1].AlphaMode = DMA2D_NO_MODIF_ALPHA;
hdma2d.LayerCfg[1].InputAlpha = 0xFF;
hdma2d.LayerCfg[1].InputColorMode = DMA2D_INPUT_L8;
hdma2d.LayerCfg[1].InputOffset = 0x0;
hdma2d.LayerCfg[1].AlphaInverted = DMA2D_REGULAR_ALPHA;
hdma2d.LayerCfg[1].RedBlueSwap   = DMA2D_RB_REGULAR;


HAL_DMA2D_Init(&hdma2d);
HAL_DMA2D_ConfigLayer(&hdma2d, 1);

hal_dma2d_handle_t hdma2d;
hal_dma2d_mem_copy_config_t p_conf;
/* DMA2D initialization */
HAL_DMA2D_Init(&hdma2d, HAL_DMA2D);

/* DMA2D output configuration */


p_conf.output.p_dest  = (void const*) (uint32_t)&L8_result;
p_conf.output.color_mode = HAL_DMA2D_OUTPUT_COLOR_ARGB8888;
p_conf.output.offset = 0;



/* DMA2D input configuration */
p_conf.input.p_src = (void const*) (uint32_t)&ARGB8888_Tab;
p_conf.input.alpha_mode = HAL_DMA2D_INPUT_ALPHA_NO_MODIF;
p_conf.input.alpha_value  = 0xFF;
p_conf.input.color_mode   = HAL_DMA2D_INPUT_COLOR_L8;
p_conf.input.offset   = 0;


p_conf.width = 16;
p_conf.height = 16;

HAL_DMA2D_SetConfigMemCopyPFC(&hdma2d, &p_conf);

DMA2D register-to-memory transfer 

DMA2D_HandleTypeDef hdma2d;




/* DMA2D init configuration */
hdma2d.Instance = DMA2D;
hdma2d.Init.Mode = DMA2D_R2M;
hdma2d.Init.ColorMode    = DMA2D_OUTPUT_ARGB8888;
hdma2d.Init.OutputOffset = 0x0;

hdma2d.Init.RedBlueSwap  = DMA2D_RB_REGULAR;
hdma2d.Init.AlphaInverted = DMA2D_REGULAR_ALPHA;



HAL_DMA2D_Init(&hdma2d);

hal_dma2d_handle_t hdma2d;
hal_dma2d_mem_fill_config_t p_conf;
/* DMA2D initialization */
HAL_DMA2D_Init(&hdma2d, HAL_DMA2D);

/* DMA2D R2M configuration */

p_conf.output.p_dest  = (void const*) (uint32_t)&ARGB8888_result;
p_conf.output.color_mode = HAL_DMA2D_OUTPUT_COLOR_ARGB8888;
p_conf.output.offset = 0;
p_conf.fixed_color    = 0x89ADCDEF;


p_conf.width = 16;
p_conf.height = 16;

HAL_DMA2D_SetConfigMemFill(&hdma2d, &p_conf);

DMA2D memory-to-memory with blending transfer 

DMA2D_HandleTypeDef hdma2d;




/* DMA2D init configuration */
hdma2d.Instance = DMA2D;
hdma2d.Init.Mode = DMA2D_M2M_BLEND;

hdma2d.Init.ColorMode    = DMA2D_OUTPUT_ARGB8888;
hdma2d.Init.OutputOffset = 0x0;
hdma2d.Init.RedBlueSwap  = DMA2D_RB_REGULAR;
hdma2d.Init.AlphaInverted = DMA2D_REGULAR_ALPHA;

/* Foreground Configuration */

hdma2d.LayerCfg[1].AlphaMode = DMA2D_NO_MODIF_ALPHA;
hdma2d.LayerCfg[1].InputAlpha = 0xFF;
hdma2d.LayerCfg[1].InputColorMode = DMA2D_INPUT_RGB565;
hdma2d.LayerCfg[1].InputOffset = 0x0;
hdma2d.LayerCfg[1].AlphaInverted = DMA2D_REGULAR_ALPHA;
hdma2d.LayerCfg[1].RedBlueSwap   = DMA2D_RB_REGULAR;

/* Background Configuration */

hdma2d.LayerCfg[0].AlphaMode = DMA2D_NO_MODIF_ALPHA;
hdma2d.LayerCfg[0].InputAlpha = 0xFF;
hdma2d.LayerCfg[0].InputColorMode = DMA2D_INPUT_RGB565;
hdma2d.LayerCfg[0].InputOffset = 0x0;
hdma2d.LayerCfg[0].AlphaInverted = DMA2D_REGULAR_ALPHA;
hdma2d.LayerCfg[0].RedBlueSwap   = DMA2D_RB_REGULAR;


HAL_DMA2D_Init(&hdma2d);
HAL_DMA2D_ConfigLayer(&hdma2d, 1);
HAL_DMA2D_ConfigLayer(&hdma2d, 0);

hal_dma2d_handle_t hdma2d;
hal_dma2d_blending_config_t p_conf;
/* DMA2D initialization */
HAL_DMA2D_Init(&hdma2d, HAL_DMA2D);

/* DMA2D output configuration */


p_conf.output.p_dest  = (void *) OUTPUT_FRAME_BUFFER;
p_conf.output.color_mode = HAL_DMA2D_OUTPUT_COLOR_ARGB8888;
p_conf.output.offset = 0;



/* Foreground configuration */
p_conf.fg_input.p_src = (void const*) (uint32_t)&RGB565_64x80_1;
p_conf.fg_input.alpha_mode = HAL_DMA2D_INPUT_ALPHA_NO_MODIF;
p_conf.fg_input.alpha_value  = 0xFF;
p_conf.fg_input.color_mode   = HAL_DMA2D_INPUT_COLOR_RGB565;
p_conf.fg_input.offset   = 0;



/* Background configuration */
p_conf.bg_input.p_src = (void const*) (uint32_t)&RGB565_64x80_2;
p_conf.bg_input.alpha_mode = HAL_DMA2D_INPUT_ALPHA_NO_MODIF;
p_conf.bg_input.alpha_value  = 0xFF;
p_conf.bg_input.color_mode   = HAL_DMA2D_INPUT_COLOR_RGB565;
p_conf.bg_input.offset   = 0;


p_conf.width = 64;
p_conf.height = 80;

HAL_DMA2D_SetConfigBlending(&hdma2d, &p_conf);

DMA2D memory-to-memory with blending and fixed color foreground transfer 

DMA2D_HandleTypeDef hdma2d;




/* DMA2D init configuration */
hdma2d.Instance = DMA2D;
hdma2d.Init.Mode = DMA2D_M2M_BLEND_FG;

hdma2d.Init.ColorMode    = DMA2D_OUTPUT_ARGB8888;
hdma2d.Init.OutputOffset = 0x0;
hdma2d.Init.RedBlueSwap  = DMA2D_RB_REGULAR;
hdma2d.Init.AlphaInverted = DMA2D_REGULAR_ALPHA;

/* Foreground Configuration */
hdma2d.LayerCfg[1].AlphaMode = DMA2D_REPLACE_ALPHA;
hdma2d.LayerCfg[1].InputAlpha = 0x7F;
hdma2d.LayerCfg[1].InputColorMode = DMA2D_INPUT_RGB565;
hdma2d.LayerCfg[1].InputOffset = 0x0;
hdma2d.LayerCfg[1].AlphaInverted = DMA2D_REGULAR_ALPHA;
hdma2d.LayerCfg[1].RedBlueSwap   = DMA2D_RB_REGULAR;

/* Background Configuration */

hdma2d.LayerCfg[0].AlphaMode = DMA2D_REPLACE_ALPHA;
hdma2d.LayerCfg[0].InputAlpha = 0x7F;
hdma2d.LayerCfg[0].InputColorMode = DMA2D_INPUT_RGB565;
hdma2d.LayerCfg[0].InputOffset = 0x0;
hdma2d.LayerCfg[0].AlphaInverted = DMA2D_REGULAR_ALPHA;
hdma2d.LayerCfg[0].RedBlueSwap   = DMA2D_RB_REGULAR;


HAL_DMA2D_Init(&hdma2d);
HAL_DMA2D_ConfigLayer(&hdma2d, 1);
HAL_DMA2D_ConfigLayer(&hdma2d, 0);

hal_dma2d_handle_t hdma2d;
hal_dma2d_blending_fixed_color_config_t p_conf;
/* DMA2D initialization */
HAL_DMA2D_Init(&hdma2d, HAL_DMA2D);

/* DMA2D output configuration */


p_conf.output.p_dest  = (void *) OUTPUT_FRAME_BUFFER;
p_conf.output.color_mode = HAL_DMA2D_OUTPUT_COLOR_ARGB8888;
p_conf.output.offset = 0;



/* DMA2D input configuration */
p_conf.fixed_color_alpha_mode = HAL_DMA2D_INPUT_ALPHA_REPLACE;

p_conf.fixed_color_argb8888 = 0x7E308080;





p_conf.mem_input.p_src = (void const*) (uint32_t)&RGB565_64x80_1;
p_conf.mem_input.alpha_mode   = HAL_DMA2D_INPUT_ALPHA_REPLACE;
p_conf.mem_input.alpha_value  = 0x7F;
p_conf.mem_input.color_mode   = HAL_DMA2D_INPUT_COLOR_RGB565;
p_conf.mem_input.offset   = 0;


p_conf.width = 64;
p_conf.height = 80;

HAL_DMA2D_SetConfigBlendingFixFGColor(&hdma2d, &p_conf);

DMA2D memory-to-memory with blending and fixed color background transfer 

DMA2D_HandleTypeDef hdma2d;




/* DMA2D init configuration */
hdma2d.Instance = DMA2D;
hdma2d.Init.Mode = DMA2D_M2M_BLEND_BG;

hdma2d.Init.ColorMode    = DMA2D_OUTPUT_ARGB8888;
hdma2d.Init.OutputOffset = 0x0;
hdma2d.Init.RedBlueSwap  = DMA2D_RB_REGULAR;
hdma2d.Init.AlphaInverted = DMA2D_REGULAR_ALPHA;

/* Foreground Configuration */

hdma2d.LayerCfg[1].AlphaMode = DMA2D_REPLACE_ALPHA;
hdma2d.LayerCfg[1].InputAlpha = 0x7F;
hdma2d.LayerCfg[1].InputColorMode = DMA2D_INPUT_RGB565;
hdma2d.LayerCfg[1].InputOffset = 0x0;
hdma2d.LayerCfg[1].AlphaInverted = DMA2D_REGULAR_ALPHA;
hdma2d.LayerCfg[1].RedBlueSwap   = DMA2D_RB_REGULAR;

/* Background Configuration */
hdma2d.LayerCfg[0].AlphaMode = DMA2D_REPLACE_ALPHA;
hdma2d.LayerCfg[0].InputAlpha = 0x7F;
hdma2d.LayerCfg[0].InputColorMode = DMA2D_INPUT_RGB565;
hdma2d.LayerCfg[0].InputOffset = 0x0;
hdma2d.LayerCfg[0].AlphaInverted = DMA2D_REGULAR_ALPHA;
hdma2d.LayerCfg[0].RedBlueSwap   = DMA2D_RB_REGULAR;


HAL_DMA2D_Init(&hdma2d);
HAL_DMA2D_ConfigLayer(&hdma2d, 1);
HAL_DMA2D_ConfigLayer(&hdma2d, 0);

hal_dma2d_handle_t hdma2d;
hal_dma2d_blending_fixed_color_config_t p_conf;
/* DMA2D initialization */
HAL_DMA2D_Init(&hdma2d, HAL_DMA2D);

/* DMA2D output configuration */


p_conf.output.p_dest  = (void *) OUTPUT_FRAME_BUFFER;
p_conf.output.color_mode = HAL_DMA2D_OUTPUT_COLOR_ARGB8888;
p_conf.output.offset = 0;



/* DMA2D input configuration */
p_conf.mem_input.p_src = (void const*) (uint32_t)&RGB565_64x80_1;
p_conf.mem_input.alpha_mode   = HAL_DMA2D_INPUT_ALPHA_REPLACE;
p_conf.mem_input.alpha_value  = 0x7F;
p_conf.mem_input.color_mode   = HAL_DMA2D_INPUT_COLOR_RGB565;
p_conf.mem_input.offset   = 0;




p_conf.fixed_color_alpha_mode = HAL_DMA2D_INPUT_ALPHA_REPLACE;

p_conf.fixed_color_argb8888 = 0x7E308080;



p_conf.width = 64;
p_conf.height = 80;

HAL_DMA2D_SetConfigBlendingFixBGColor(&hdma2d, &p_conf);

Related concept: Separation of initialization and configuration functions

HAL DMA2D CLUT loading

HAL1

HAL2

In HAL1, there are two ways for loading the CLUT:

  • Either use HAL_DMA2D_CLUTStartLoad() in polling mode or HAL_DMA2D_CLUTStartLoad_IT() in interrupt mode.

  • Alternatively, use HAL_DMA2D_CLUTLoad(), or HAL_DMA2D_ConfigCLUT() followed by HAL_DMA2D_EnableCLUT() in polling mode. If using interrupt mode, use HAL_DMA2D_CLUTLoad_IT(). Note that this option is considered obsolete in HAL1 itself.

HAL_DMA2D_CLUTStartLoad(DMA2D_HandleTypeDef *hdma2d, const DMA2D_CLUTCfgTypeDef *CLUTCfg,
                                 uint32_t LayerIdx)
HAL_DMA2D_CLUTStartLoad_IT(DMA2D_HandleTypeDef *hdma2d, const DMA2D_CLUTCfgTypeDef *CLUTCfg,
                                    uint32_t LayerIdx)

HAL_DMA2D_CLUTLoad(DMA2D_HandleTypeDef *hdma2d, DMA2D_CLUTCfgTypeDef CLUTCfg,
                                               uint32_t LayerIdx)
HAL_DMA2D_CLUTLoad_IT(DMA2D_HandleTypeDef *hdma2d, DMA2D_CLUTCfgTypeDef CLUTCfg,
                                                   uint32_t LayerIdx)
HAL_DMA2D_ConfigCLUT(DMA2D_HandleTypeDef *hdma2d, DMA2D_CLUTCfgTypeDef CLUTCfg, uint32_t LayerIdx)
HAL_DMA2D_EnableCLUT(DMA2D_HandleTypeDef *hdma2d, uint32_t LayerIdx)

In HAL2, the CLUT transfer configuration is managed by: 

- in polling mode:
HAL_DMA2D_StartCLUTLoad(hal_dma2d_handle_t *hdma2d, const hal_dma2d_clut_config_t *p_clut_config,
                            hal_dma2d_input_t input)
- in interrupt mode:
HAL_DMA2D_StartCLUTLoad_IT(hal_dma2d_handle_t *hdma2d, const hal_dma2d_clut_config_t *p_clut_config,
                               hal_dma2d_input_t input)

Related concept: Other HAL DMA2D changes

HAL DMA2D line event program

HAL1

HAL2 

HAL_DMA2D_ProgramLineEvent(DMA2D_HandleTypeDef *hdma2d, uint32_t Line)

HAL_DMA2D_EnableWaterMark(hal_dma2d_handle_t *hdma2d, uint32_t line)

HAL DMA2D dead time feature enable

HAL1

HAL2 

HAL_DMA2D_EnableDeadTime(DMA2D_HandleTypeDef *hdma2d)

HAL_DMA2D_EnableDeadTime(hal_dma2d_handle_t *hdma2d)

HAL DMA2D dead time feature disable

HAL1

HAL2 

HAL_DMA2D_DisableDeadTime(DMA2D_HandleTypeDef *hdma2d)

HAL_DMA2D_DisableDeadTime(hal_dma2d_handle_t *hdma2d)

HAL DMA2D dead time feature configuration

HAL1

HAL2 

HAL_DMA2D_ConfigDeadTime(DMA2D_HandleTypeDef *hdma2d, uint8_t DeadTime)

HAL_DMA2D_SetConfigDeadTime(hal_dma2d_handle_t *hdma2d, uint8_t dead_time_cycle)